Chapter 7: Strings
From book Python Programming (Problem solving, Packages and Libraries) published by McGraw Hill Education (India) Private limited.
By:
Note the following:-
>>> symbol and therefore cannot be directly executed. If you want to execute them on IDLE or Jupyter, you need to manually remove the >>> symbol.Markdown and code cells (extension .ipynb) and then downloaded as html. If someone wants to "modify" or "extend' this document, you may ask for the original .ipynb file by sending me an e-mail at:- 999.anuraggupta@gmail.com7.2. Creating, initializing and accessing elements of a string
7.2.1 Creating strings
You can create a string in Python in a number of different ways. Some such ways are shown as follows:
(i) Using single quotes
A literal string can be created using single quotes, such as ‘abc’. If a string is created using single quotes, it can include double quotes inside. Hence, ‘a”b”c’ is a valid string in Python. An empty or null string is created by ‘’. On IDLE, it will appear as follows:
# ---ON IDLE---
>>> myStr = 'abc'
>>> myStr
'abc'
>>> myStr2 = 'a"b"c'
>>> myStr2
'a"b"c'
>>>
(iii) Using “triple single” or “triple double” quotes
Strings can also be created using triple quotes (single or double) when you need to span the string on multiple lines. On IDLE:
# ---ON IDLE---
>>> '''abc''' # Triple single quoted string on single line
'abc'
>>> """abc""" # Triple double quoted string on single line
'abc'
>>> '''ab # Triple single quoted string on multiple lines
c'''
'ab\nc'
>>> """ab # Triple double quoted string on multiple lines
c"""
'ab\nc'
(iv) Using the str(object) builtin function
As explained earlier, everything in Python is an object. So data types, such has integers, floats, lists, tuples, and so on are all objects. These objects have a “string representation”. Without going into too muchdetail, it is sufficient to understand that if an object is given as an argument to a str(object) function, it will convert it into a string. If no argument is given, for instance, str(), then an empty string is created. On IDLE:
# ---ON IDLE---
>>> str(1) #integer 1 converted to string
'1'
>>> str([1,2,'a']) #List converted to string
"[1, 2, 'a']"
>>> str() # Empty string created
''
>>>
7.2.2 String indexing
Strings in Python are ordered collections of characters. “Ordered” means that it is a sequence of characters. In Python, the individual characters are accessed by their index, which starts from 0 and ends at one less than the length of the string. Thus, if the length of a string is n, then its index will be from 0 to n-1. (This is similar to C++). However, in Python, you can access the individual characters of a string using negative index also. The last character in the string has a negative index of -1 and the first character (for a string of n characters ) has an index of –n. The indexing applies to string variables as well as string literals. This is clear from the following:
myStr = 'Hello World!'
print('Character at index 0->', myStr[0])
# You can also use indexing on a string Literal
print('Hello World'[0]) # Accessing character at index 0 of a literal string
The index of a string starts from 0. In fact, all indexes in all sequences in Python start from 0. The negative index starts from -1 as shown in Figure 1.1 and -1 is the index of the last character in the string. The other important characteristic of a string sequence is its immutability, which means you cannot change any character appearing at a particular index (position) of the string.
# ---ON IDLE---
>>> myString = "Hello World!"
>>> myString[0] # Index 0 is the first character in the string
'H'
>>> myString[-1] # Index -1 is the last character in the string
'!'
>>> myString[15] # myString has 12 characters so index can only be from 0 to 11 or -1 to -12
Traceback (most recent call last):
File "<pyshell#3>", line 1, in<module>
myString[15]
IndexError: string index out of range
>>> myString[0] = '0'#Error because strings are immutable
Traceback (most recent call last):
File "<pyshell#4>", line 1, in<module>
myString[0] = '0'
TypeError: 'str' object does not support item assignment
An example that shows how to access the individual characters of a literal string is as follows:
# ---ON IDLE---
>>>'cat'[0] # Syntax OK
'c'
>>>'cat'.[0] # Syntax not OK since dot ie '.' not allowed
SyntaxError: invalid syntax
7.2.3 Special character and escape sequenc
Some common escape sequences of both types are given in Table 1.1.of the book.
There use will be clear from the following on IDLE:
# ---ON IDLE---
>>> s1 = 'abc\ndef'# \n will act as a new line
>>>print(s1)
abc
def
>>>print('abc\tdef') # \t will act like a tab
abc def
>>>print('abc\\\n\\def') #\\\n will act like a \ followed by a new line
abc\
\def
>>>
7.3.1 Traversing a string using ‘for’ loop
You can traverse or iterate over a string using a ‘for’ loop as follows:
myStr = 'ABCD'
for iChar in myStr:
print(iChar)
7.3.2 Traversing a string using while loop
You can loop over a string using the ‘while’ loop. The number of iterations will depend upon the length of the string, which can be found using the len(string) function as follows:
myStr = 'ABCDEF'
myCount = len(myStr)
iCount = 0
while iCount < myCount:
print('At index ',iCount, '->',myStr[iCount])
iCount = iCount +1
7.3.3 Traversing a string using ‘for’ loop with the range() function
You can traverse a string using range() also, as follows:
myStr = 'ABCDEF'
myCount = len(myStr)
iCount = 0
for iCount in range(myCount):
print('At index ',iCount, '->',myStr[iCount])
iCount = iCount +1
7.4 String Operations
7.4.1 The plus, that is, ‘+ ’ operator
In Python, the ‘+’ operator can be used to concatenate two strings.
The following script prints the odd and even characters of a string input by the user:
myS = input("Give a string ")
L = len(myS)
S1 = S2 = '' # S1 and S2 will hold odd and even characters respectively
for x in range(L):
if x % 2 == 0:
S1 = S1 + myS[x]
else:
S2 = S2 + myS[x]
print('Odd characters-> ',S1, ' Even characters-> ', S2)
7.4.2 The multiplication operator ‘ *’
In Python, the multiply, that is, ‘*’ operator can be used to multiply a string with an integer. But you cannot multiply two strings.
The following code shows how you can multiply a string with a number to generate a pyramid of numbers:
for x in range(5):
y = x+1 # start the count from 1 not 0
print(y * str(y)) # str(y) will cast y to a string)
7.4.3 Operators “in” and “not in”
Python has two membership operators, namely “in” and “not in”. These two membership operators can be used to test whether a particular value/ variable/ data exists (or doesn’t exist) in a sequence (that is, string, list, tuple, set and dictionary).
The “in” and “not in” operators generate a “boolean context”, that is, the expression using “in” and “not in” will generate either a “True” or a “False”.
This will be clear from the following:
# ---ON IDLE---
>>>'a' in 'abc'
True
>>>'d' in 'abc'
False
>>>'d' not in 'abc'
True
>>>
7.4.4 String slicing
The slice operation on IDLE is as follows:
# ---ON IDLE---
>>> myStr = 'Hello World!'
>>> mySlice = myStr[1:6] # Assigning a string slice to a new string variable
>>> mySlice
'ello '
>>>'Hello World!'[1:6] # Slicing a string literal
'ello '
>>> myStr[-11:-7] # Can use negative index to slice string also
'ello'
The basics of slicing can be summarized as follows:
A string (which is a sequence object), can be sliced using a pair of indices in square brackets and separated by a colon.
The index on the left is lower bound and is included in the slice.
The index on the right is the upper bound and is excluded from the slice.
Slicing creates a new object, that is, a new string.
Further, you can exclude (writing in square brackets) either the upper bound or the lower bound or both. o If lower bound is excluded, it defaults to 0. (For example myStr[:6] is same as myStr[0:6]) o If upper bound is excluded it defaults to the index of the last character of the string (Which is also -1). For example myStr[1:] is same as myStr[1:-1]
# ---ON IDLE---
>>> myStr = 'Hello World!'
>>> myStr[:6] #Lower bound excluded so lower bound defaults to 0
'Hello '
>>> myStr[6:] # Upper bound excluded so upper bound defaults to end of string
'World!'
>>> myStr[6:-1] #Same as myStr[6:11]
'World'
>>> myStrCopy = myStr[:] # Both bounds excluded, creates copy
>>> myStrCopy
'Hello World!'
>>> myStr[:-1] # Entire string excluding last character
'Hello World'
7.4.5 String extended slicing
Extended slice is of format myStr[x: y: z]. x is start index, y is stop index and z is the step or stride.
Any of the three can be excluded. If z is excluded it defaults to +1. As before, if x is excluded, it defaults to 0 and if y is excluded, it defaults to index of the last character of the string.
Note that as before, the character at index x is ALWAYS included and the character at index y is NEVER included.
Consider the following example:-
# ---ON IDLE---
>>> myLetters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> myLetters[1:25:2]
'BDFHJLNPRTVX'
You can also use a negative stride, that is, -1 to reverse the order of the character of a stringm, as follows:
# ---ON IDLE---
>>> myLetters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> myLettersRev = myLetters[:: -1] # Creates a new string which is reverse of old
>>> myLettersRev
'ZYXWVUTSRQPONMLKJIHGFEDCBA'
7.4.6 Comparison of strings using relational operators
As explained earlier, comparison generates Booleans.
You can compare not only number “types”, such as int and float, but even strings.
Text comparisons are based on ordering of characters in the Unicode set. For instance, in the English language, the unicodes for uppercase come before lowercase (that is, uppercase precedes lowercase).
Hence, a string beginning with an uppercase letter will be “smaller” than a string beginning with a lower case letter.
# ---ON IDLE---
>>>'boy'<'girl' # Alphabetic order
True
>>>'Boy'<'boy' # Uppercase before lowercase
True
>>>'Girl'<'boy' # All uppercase before lowercase so G before b
True
`7.6 String functions versus string methods
7.6.1 str.capitalize() where str is a string
Return a copy of the string with its first character capitalized and the rest lowercased.
# ---ON IDLE---
>>> str = 'abc'
>>> str.capitalize()
'Abc'
>>> str1 = '?abc'# If first letter non-alphabet, then does nothing
>>> str1.capitalize()
'?abc'
7.6.2 str.count(sub[, start[, stop]])
Remember, sub is the substring being searched in the string str.
The method count() takes a substring as a parameter. It then checks and returns the number of occurrences of the “sub-string” in the string.
Note that the parameter substring given to the count method also has two optional parameters, namely “start” and “stop”.
Therefore, if you don’t give these two “optional parameters, that is, start and stop” then the entire substring is checked within the string. With the count() method, you get the “number of occurrences” of the given substring “sub” in the range [start, stop]. Optional arguments “start” and “stop” have the same meaning as they do in “slice notation”.
The following examples will clarify the concept:
# ---ON IDLE---
>>> s1 = '01234'
>>> s1.count('0')# Here ‘0’ is the substring being searched in string s1
1
>>> s1.count('0', 1) # count will start from index 1, hence count is 0
0
>>> s1.count('4', 0, 5) #length of string is 5, so the last
#character is considered if 5 is last parameter
1
>>> str.count('4', 0, 4) # last param is 4 so character at index 4
# ie '4' is not counted
0
7.6.2.1 str.find(pat[, start[, stop]])
This method gives the starting index in the string where substring “pat” is present, such that “pat” occurs in the slice pat[start: stop].
The optional arguments “start” and “stop” are interpreted as in slice notation.
The method returns -1 if “pat” is not found.
# ---ON IDLE---
>>> str1 = 'abc'
>>> str2 = '01234abc89'
>>> str2.find(str1)
5
>>> str2.find(str1,5)# substring ‘abc starts at index. Final also begins at idex5
5
>>> str2.find(str1,6)# Not found
-1
The find() method provides only the position of a “pat”, that is, a pattern in a string, that is, the index of occurrence of the sub-string.
If you don’t need the index of the sub-string in the string and simply want to know if the sub-string is present in the string, then use the ‘in’ operator instead, as shown:
To check if pat is a substring or not, use the ‘in’ operator:
# ---ON IDLE---
>>>'abc' in 'defabcghi'
True
7.6.2.2 str.isalnum()
The method isalnum() is used to check if all characters in a string are alphanumeric or not.
The method returns True if all characters in the string are alphanumeric and the string “str” has at least one character (that is, it is not an empty string), False otherwise.
(Note that methods which begin with ‘is’ like isalnum() generally return a bool
# ---ON IDLE---
>>>'abcd12345'.isalnum()
True
>>>'abc 123'.isalnum()# Contains a space which is not alphanumeric
False
>>>'@123asd'.isalnum()
False
7.6.2.3 str.isalpha()
This method returns True if all characters in the string “str” are alphabetic and it has at least one character, and False otherwise.
# ---ON IDLE---
>>>'abcd'.isalpha()
True
>>>''.isalpha()# Empty string so ‘’.isalpha() returns False
False
>>>'12sa'.isalpha()
False
1. str.isdigit()
This method returns True if all characters in the string “str” are digits and it has at least one character, which is False otherwise.
# ---ON IDLE---
>>>'abc123'.isdigit() #Since there are alphabet so False
False
>>>'123 '.isdigit() #Digits with blank space also False
False
>>>'123'.isdigit() # Only digits without white space True
True
7.6.3 Checking for a “palindrome”
7.6.3.1 Method 1 to check for a palindrome`
def is_Pal(in_string):
print("String given-> ", in_string)
iter_var = len(in_string) // 2
for iVar in range(iter_var):
print('Iteration number->', iVar)
if in_string[iVar] != in_string[-(iVar + 1)]:
print("Alphabet",in_string[iVar],'Didn’t match',in_string[-(iVar +1)])
return False
print(in_string[iVar]," matched ",in_string[-(iVar + 1)])
return True
# Test 'abcdcba'
checkPal = is_Pal('abcdcba')
print('"abcdcba" is palindrome-> ',checkPal)
print('****************')
# Test 'abcdxcba'
checkPal = is_Pal('abcdxcba')
print('"abcdxcba" is palindrome? ',checkPal)
7.6.3.2 Method 2 to check for a palindrome
Another way to check for a palindrome word is to generate a string in reverse and then compare it to the original.
A string can be reversed using the extended slicing with a negative step.
This is shown in the following script:
myStr = input('Give a palindrome->')
print('You gave-> ', myStr)
myStrRev = myStr[::-1] # This creates reverse of the input string
print('The reverse of your input is -> ', myStrRev)
if myStr == myStrRev:
print(myStr, ' is a Palindrome')
else:
print(myStr, ' is not a Palindrome')
7.7 A short note on string module
Note that the function str() is different from the string module in Python.
In Python, the string is a module, which needs to be imported using the import statement.
In fact, with Python 3.x you don’t need to import the string module since most of the functionalities provided by this module are already available in the string type.
However, the string module has a number of built-in constants, which can be used.
# ---ON IDLE---
>>>import string
>>> string.ascii_uppercase # Gives uppercase letters
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase # Gives lowercase letters
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_letters # Gives all alphabet both upper and lower
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.digits # Gives all digits
'0123456789'
>>> string.hexdigits # Gives all hex digits ie 0-9 and A-F
'0123456789abcdefABCDEF'
>>> string.octdigits # Gives all oct digits ie 0-7
'01234567'
>>> string.punctuation # Gives all punctuation marks
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>> string.whitespace # Gives all white spaces including tabs and newline
' \t\n\r\x0b\x0c'
>>>
One question that arises is, why do you need such sets of constants in the string module? The following code shows how you can use these string constants:
import string
myS = input("Give a string ")
for c in myS:
if c in string.ascii_letters:
print(c, " is a letter")
elif c in string.digits:
print(c, " is a digit")
elif c in string.whitespace:
print(c, " is a whitespace")
elif c in string.punctuation:
print(c, " is a punctuation mark")
else:
print(c, " is something else")
Beyond text book
1. Python has a module calendar which provides useful methods for working with a calendar.
An example of how this module can be used to print a calendar for March 2019, is as follows:
import calendar
# year = 2019, month = 3
print(calendar.month(2019, 3))
2. Using datetime module
(This exercise can be better done after reading OOP concepts).
Python also has a datetime module. This module provides classes and methods for manipulating dates and times.
The datetime.datetime class returns a datetime object.
The following code shows the use of some common methods of the datetime module:
import datetime
# You can create a datetime object but must give at least YYYY-MM-DD
some_time = datetime.datetime(2019, 1, 1)
print('some_time 1st jan 2019->', some_time)
# datetime.datetime.now for current date-time
now_time = datetime.datetime.now()
print('now_time ->', now_time) # Format is YYYY-MM-DD HH:mm:ss.ssssss
# ISO 8601 is an international standard for representing dates and times
print('isoformat->', now_time.isoformat())
# datetime object has a strftime() method to format time in particular way
# If you want %d/%m/%Y then
print('strftime->', now_time.strftime("%d/%m/%Y"))
# strftime() method is used to create a datetime object from a string
print('strftime with tz->', now_time.strftime("%Y-%m-%d %H:%M:%S %Z%z"))
# For details on strftime() and strptime() Behavior see:-
# https://docs.python.org/3.4/library/datetime.html#strftime-and-strptime-behavior
3. Naïve vs aware datetime objects. (Attempt only after reading OOP concepts)
A “naive” datetime object has no time-zone “awareness”.
The easiest way to check whether a datetime object is “aware” or “naive” is to check for an attribute called “tzinfo” of the datetime object.
If the datetime object is naïve, then this attribute will be None as shown:-
import datetime
obj_naive = datetime.datetime.now()
print(obj_naive.tzinfo)
Python has a pytz module, which brings in the “Olson database” into Python and thereby you can make a “naive” object into an “aware” object. The following about this module are relevant:
import pytz
print(pytz.all_timezones_set)
So the steps in converting a timezone “aware” object are as follows:
You can create a timezone aware object as shown:
import datetime
import pytz
# The olson database has 'Asia/Kolkata', 'Asia/Calcutta'
# --- Step 1. Create a naive object for current date-time
naive_dt = datetime.datetime.now()
# Its tzinfo is None
print("tzinfo->", naive_dt.tzinfo) # tzinfo-> None
#--- Step 2. Create a timezone object for 'Asia/Kolkata'
tz_kolkata = pytz.timezone('Asia/Kolkata')
#--- Step 3. Use localize(dt) method to create "aware" object
aware_dt = tz_kolkata.localize(naive_dt)
print('aware_dt->', aware_dt.tzinfo)
The following code is another example of how the pytz module can be used to make the timezone aware date-time objects:-
import pytz
print('dir(pytz)->', dir(pytz))
# Gives 2 letter code of countries. Have to cast to list
print('Country 2 letter code->', list(pytz.country_names))
# Gives names of common time zones.
print('common timezones->', pytz.common_timezones)
# India has only 1 time zone 'Asia/Kolkata'
print('timezone for India->', pytz.country_timezones['IN'])
# time-zone aware time for India
now_india = datetime.datetime.now(pytz.timezone('Asia/Kolkata'))
# Confirm that IST is +05:30
print('time zone aware for India->', now_india)